glyph cache: Upload glyphs incrementally

This does not work yet.

vulkan: pass the context when creating a glyph cache

vulkan: Add an upload_region api to GskVulkanImage

This will let us update larger textures incrementally.
Sadly, it does not work yet.

Add some debug output for the glyph cache

Print out some statistics and dump the glyph caches to a png,
for now.

Make the glyph cache grow as needed

Make it possible to have more than one texture in the
glyph cache, and create new ones when we run out of space
in the existing ones.

vulkan: Move glyph cache to a separate file

Otherwise things will get too messy.

vulkan: Better glyph cache api

Move the glyph caching api to something that can support using
multiple textures. We now split the text render ops into multiple
ops for different textures, and make each op render just a substring
of the text node's glyph string.

ToolItem: Fix nullable annotation put on wrong arg

D’oh

gdkseatdefault: Grab touch events where applicable

gdk_seat_default_grab() grabs POINTER_EVENTS if the capability is
GDK_SEAT_CAPABILITY_ALL_POINTING. But that enumerator is a union that
includes GDK_SEAT_CAPABILITY_TOUCH, but we never grabbed TOUCH_EVENTS,
an unused macro that was presumably created with this purpose in mind.

So, check which of the ALL_POINTING capabilities we have, and set the
right mask of POINTER_EVENTS and/or TOUCH_EVENTS as required.

As part of this, explicitly let TABLET_STYLUS take over pointer events,
as this is the intended behaviour and was the effective result before.

This should fix touch events being lost in migrating from Device.grab()
to Seat.grab(GDK_SEAT_CAPABILITY_ALL_POINTING), as found by Inkscape.

https://bugzilla.gnome.org/show_bug.cgi?id=781757

Overlay: Document style classes added per position

Update POTFILES.in

gtkmain: Ensure to emit real GDK_LEAVE_NOTIFY events.

If we got a GDK_LEAVE_NOTIFY event from GDK, we would reset the
GtkPointerFocus, but the event would be silently consumed.

gdk/x11: Implement GDK_CROSSING_TOUCH_BEGIN/END/DEVICE_CHANGE events

The behavior where a touchpoint takes over the pointer position is
really backend dependent. Since this went away from the generic code,
implement it here.

gdk: Remove remainings of fake crossing event delivery across touch

This was by all lights broken, and is basically an implementation detail
of the X11 backend since the pointer emulating touch just steals the pointer
cursor, so should be reimplemented there.

gdk: Coalesce 2 GdkWindow fields in GdkPointerWindowInfo struct

One used to point to the toplevel and the other to the client-side window
that the pointer pointed to. The latter was made to be like the former in
most places, so put those together, and fix the remaining cases where the
variable might not end up with a toplevel/native window.

gdk: Remove unused variable

It was supporting API that has been removed.

gdk: Remove implicit touch grab accounting

This is not necessary now that there's no client-side windows to track.
The only removed piece that could make sense is emission of grab broken
events, but it's already an stretch since the semantics of those with
multi-touchpoint is unclear.

Anyhow, This should be fixed at the GTK level, while we let GDK deal with
seat/device level grabs.

gdk: Remove motion hints

Motion hints are now literally a thing of the past. Everything should be
using the full motion event stream.

gdk: Drop generation of synthesized crossing events on grabs

GDK just needs to care about toplevels nowadays, which means these events
are already delivered from the windowing. We don't need to generate
intra-window crossing events ourselves.

gtk: Remove 2BUTTON and 3BUTTON events and event types

Those should be interpreted by widget-local gestures, not guessed at a
high level with no notions of the specific context. Users will want
GtkGestureMultiPress to replace these events.

gdk: Remove array of event masks

This has been unused since all events are just forwarded instead of
checking client-side windows evmasks.

gtklistbox: Remove enter/leave/motion event handlers

Those worked similarly to those in GtkFlowBox, but would additionally
handle "active" state for child rows. Simplify this to just enabling/
disabling active state on gesture press/release, we don't get the
nice state updates when hovering around with a mouse button pressed,
but the rationale from flowbox applies here, and makes a nice cleanup.

gtkcolorswatch: Remove enter/leave event handlers

Those just maintained prelight state, which is already managed internally.

gtkbutton: Remove enter/leave event handlers

They just maintain priv->in_button and widget state up-to-date, this
basically matters during user interaction, and is already maintained
in the gesture ::update handler. This seems to be sufficient.

gtkflowbox: Drop crossing/motion event handlers

Those basically controlled priv->active_child_active, which would
1) trigger a redraw when the pointer enters/leaves it, and 2) ensure
that press/release happen on the same child for it to be activated.

The former is not necessary, and the latter can be simplified by
just checking again the child on the coordinates given by the
::release gesture handler. This makes all enter/leave/motion_notify
event handlers unneeded.

gtkspinbutton: Remove motion notify handler

It does nothing nowadays.

gtkcalendar: Use scroll event controller

gtkscrolledwindow: Use scroll event controller

All kinetic scrolling initial velocity calculations are now
taken from the scroll controller. The handling of timeouts
to snap back when overshooting has been also made to just
apply on devices that can't emit ::scroll-begin/end.

gtkspinbutton: Use scroll event controller

gtkscalebutton: Use scroll event controller

gtkrange: Use scroll event controller

gtkpathbar: Use scroll event controller

gtkmenu: Use scroll event controller

gtkcombobox: Use scroll event controller

gtk: Add GtkEventControllerScroll

This is a GtkEventController implementation to handle mouse
scrolling. It handles both smooth and discrete events and
offers a way for callers to tell their preference too, so
smooth events shall be accumulated and coalesced on request.

On capable devices, it can also emit ::scroll-begin and
::scroll-end enclosing all ::scroll events for a scroll
operation.

It also has builtin kinetic scrolling capabilities, reporting
the initial velocity for both axes after ::scroll-end if
requested.

gdk/x11: Avoid delivering emulated scroll events

We now just propagate the real event, and let the caller deal
with smooth vs discrete.

gdk/wayland: Drop emission of emulated scroll events

A wl_pointer.frame can now only result on one scroll event
being emitted.

gtk: Change gtk_propagate_event() to propagate both ways.

This change is made for consistency, it doesn't make sense to expose
one-way propagation, as it can only break expectations from GTK+. This
function might be made entirely private in the future, but it still
makes sense to do this in one go for our internal usecases.

gdk/x11: Drop motion/button events emulated from touch

We now always listen to touch events. Just avoid delivering both
types of events.

eventcontroller: Drop event_mask API

This is unchecked, we can remove it entirely as well.

gtkwidget: Drop pointer emulation out of touch events

Users of touch events are required to either use a GtkGesture, or handle
touch events themselves.

gtk: Run GtkWidgetClass event signals inside a GtkEventController

This will allow further cleanups and optimizations in capture/target/bubble
event delivery. For simplicity, ATM every widget will receive its own
GtkEventControllerLegacy, it could be desirable to add finer control over
this in the future, so widgets that fully use event controllers for input
management can do away without this legacy piece.

testsuite: Use GdkEvent API

tests: Use GdkEvent API

examples: Use GdkEvent API

widget: Give up on GdkEvent api for now

treeview: Give up on GdkEvent api for now

There's multiple places where events are manually generated
here, this needs more thought.

entry accessible: Give up on GdkEvent api for now

Just include gdkeventsprivate.h here for now. This may be
resolved by just dropping icon support from GtkEntry down
the road.

a11y: Stop listening for configure events

This needs to be done differently.

Add some more GdkEvent getters

gtk-demo: Use GdkEvent API

treev view column: Use GdkEvent API

clipboard: Use GdkEvent API

a11y: Use GdkEvent API in some places

More work needed.

tooltip: Use GdkEvent API

And at the same time, reshuffle things slightly to avoid
creating synthetic events.

text view: Use GdkEvent API

text handle: Use GdkEvent API

selection: Use GdkEvent API

search bar: Use GdkEvent API

scrolled window: Use GdkEvent API

places view: Use GdkEvent API

place sidebar: Use GdkEvent API

path bar: Use GdkEvent API

pad controller: Use GdkEvent API

menu shell: Use GdkEvent API

menu item: Use GdkEvent API

im context simple: Use GdkEvent API

header bar: Use GdkEvent API

gesture zoom: Use GdkEvent API

gesture swipe: Use GdkEvent API

gesture single: Use GdkEvent API

gesture rotate: Use GdkEvent API

gesture drag: Use GdkEvent API

gesture: Use GdkEvent API

window accessible: Use GdkEvent API

widget accessible: Use GdkEvent API

Add more GdkEvents API

xim: Convert to GdkEvent API

settings: Convert to GdkEvent API

gesture rotate: Partially convert to GdkEvent API

gesture: Partially convert to GdkEvent API

flowbox: Convert to GdkEvent API

file chooser widget: Covert to GdkEvent API

expander: Convert to GdkEvent API

entry: Convert to GdkEvent API

dnd: Convert to GdkEvent API

cell renderer accel: Convert to GdkEvent API

bindings: Convert to use GdkEvent API

Add more getters for event fields

gdk: Make GdkEvent structs/union opaque

All users are forced to deal with events as opaque pointers, only
using API to access the info.

bindings: Partially update to using GdkEvent API

a11y: Partially update to using GdkEvent API

inspector: Update to using GdkEvent API

gtkwindow: Update to using GdkEvent API

treeview: Update to using GdkEvent API

tooltip: Update to using GdkEvent API

textview: Update to using GdkEvent API

texthandle: Update to using GdkEvent API

spinbutton: Update to using GdkEvent API

scrolledwindow: Update to using GdkEvent API